package com.young.testcoroutine

import kotlinx.coroutines.*
import org.junit.Test
import kotlin.system.measureTimeMillis

/**
 * Author：young
 * .
 * Time： 2022/9/12 12:29 周一
 * .
 * Desc：协程的启动模式
 */
class CoroutineTest03 {

    /**
     * 测试启动模式 CoroutineStart.DEFAULT
     */
    @Test
    fun test_start_mode() = runBlocking {
        val job1 = launch(start = CoroutineStart.DEFAULT) {
            // 如果立刻调用了  job1.cancel() ，这里就不会执行了
            println("协程调度")
            delay(10000)
            println("job1 完成了")
        }
        println("协程调度 111")
        // 延时 1 秒，如果这里注释了，让  job1.cancel() 立刻执行
        delay(1000)
        // 关闭协程
        job1.cancel()
    }

    /**
     * 测试启动模式 CoroutineStart.DEFAULT
     */
    @Test
    fun test_start_mode1() = runBlocking {
        val job1 = launch(start = CoroutineStart.ATOMIC) {
            // 如果立刻调用了 job1.cancel()，下面的打印依旧会打印，直到遇到  delay(10000)
            println("协程调度")
            delay(10000)
            println("job1 完成了")
        }
        println("协程调度 111")
        // 延时 1 秒，如果注释了，让下面的  job1.cancel() 立刻执行，上面的协程还是会调用
//        delay(1000)
        // 关闭协程
        job1.cancel()
    }

    /**
     * 测试启动模式 CoroutineStart.LAZY
     */
    @Test
    fun test_start_mode2() = runBlocking {
        val job1 = async(start = CoroutineStart.LAZY) {
            println("协程启动了")
            30
        }
        println("协程调度 111")
        job1.join()
    }

    /**
     * 测试启动模式 CoroutineStart.UNDISPATCHED
     */
    @Test
    fun test_start_mode3() = runBlocking {
        val job1 = async(start = CoroutineStart.UNDISPATCHED) {
            println("协程启动了")
            30
        }
        println("协程调度 111")
        job1.join()
    }

    /**
     * 在 io 启动协程，在当前线程执行任务
     */
    @Test
    fun test_start_mode4() = runBlocking {
        val job1 = async(context = Dispatchers.IO, start = CoroutineStart.UNDISPATCHED) {
            println("协程启动了 ${Thread.currentThread().name}")
            30
        }
        println("协程调度 111")
        job1.join()
    }

}